package com.zhu.java8;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: zhujiabao
 * @Date: 2022/04/14/15:40
 * @Description: 参考：https://blog.csdn.net/lgxzzz/article/details/111228302
 */
public class LambdaTest {

    /*1、替代匿名内部类*/
    @Test
    public void runnableTest(){
        //匿名内部类写法
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("The old runable now is using!");
            }
        }).start();

        //lambda写法
        new Thread(() -> System.out.println("It's a lambda function!")).start();
    }

    /*2、使用lambda表达式对集合进行迭代*/
    @Test
    public void iterTest(){
        List<String> languages = Arrays.asList("java","python","C++","PHP");

        //before java8
        for (String each :
                languages) {
            System.out.println(each);
        }

        //after java8
        //lambda写法
        languages.forEach(x -> System.out.println(x));
        //方法引用写法 ::
        languages.forEach(System.out::println);

    }

    /*3、用lambda表达式实现map*/
    /*
    * map函数可以说是函数式编程里最重要的一个方法了。
    * map的作用是将一个对象变换为另外一个。在我们的例子中，就是通过map方法将cost增加了0,05倍的大小然后输出。
    * */
    @Test
    public void mapTest(){
        List<Double> cost = Arrays.asList(10.0,20.0,30.0);
        cost.stream().map(x -> x + x*0.05).forEach(System.out::println);
    }

    /*4、用lambda表达式实现map与reduce*/
    /*
    * 既然提到了map，又怎能不提到reduce。reduce与map一样，也是函数式编程里最重要的几个方法之一。。。
    * map的作用是将一个对象变为另外一个，而reduce实现的则是将所有值合并为一个，请看：
    * */
    @Test
    public void mapReduceTest(){
        List<Double> cost = Arrays.asList(10.0,20.0,30.0);
        double allCost = cost.stream().map(x -> x + x*0.05).reduce((sum,x) -> sum + x).get();
        System.out.println(allCost);
    }
    //如果我们用for循环来做这件事情：
    //相信用map+reduce+lambda表达式的写法高出不止一个level。
    @Test
    public void sumTest(){
        List<Double> cost = Arrays.asList(10.0,20.0,30.0);
        double sum = 0;
        for (Double each : cost){
            each = each + each*0.05;
            sum += each;
        }
        System.out.println(sum);
    }

    /*5、filter操作*/
    /*
    * filter也是我们经常使用的一个操作。在操作集合的时候，经常需要从原始的集合中过滤掉一部分元素。
    * */
   @Test
    public void filterTest(){
        List<Double> cost = Arrays.asList(10.0,20.0,30.0,40.0);
        List<Double> filterCost = cost.stream().filter(x -> x>25.0).collect(Collectors.toList());
        filterCost.forEach(System.out::println);
    }


    /*6、与函数式接口Predicate配合*/
    /*
    * 除了在语言层面支持函数式编程风格，Java 8也添加了一个包，叫做 java.util.function。
    * 它包含了很多类，用来支持Java的函数式编程。其中一个便是Predicate，
    * 使用 java.util.function.Predicate 函数式接口以及lambda表达式，
    * 可以向API方法添加逻辑，用更少的代码支持更多的动态行为。
    * Predicate接口非常适用于做过滤。
    * */
    public static void main(String[] args) {
        List<String> languages = Arrays.asList("Java","Python","scala","Shell","R");
        System.out.println("Language starts with J: ");
        filterTest(languages,x -> x.startsWith("J"));
        System.out.println("\nLanguage ends with a: ");
        filterTest(languages,x -> x.endsWith("a"));
        System.out.println("\nAll languages: ");
        filterTest(languages,x -> true);
        System.out.println("\nNo languages: ");
        filterTest(languages,x -> false);
        System.out.println("\nLanguage length bigger three: ");
        filterTest(languages,x -> x.length() > 4);
    }
    public static void filterTest(List<String> languages, Predicate<String> condition) {
        languages.stream().filter(x -> condition.test(x)).forEach(x -> System.out.println(x + " "));
    }

}
